The Rust Programming Language: Immutability and Constants

In a statically typed language, immutability is the foundational state of data, ensuring memory safety and predictable execution. While variables can be shadowed or made mutable, Constants take this a step further by binding a value to a name permanently.

1. The Rigidity of Constants

Unlike standard variables where Type Inference allows the compiler to deduce the data type, constants strictly require an explicit type annotation (e.g., : u32). This maintains rigorous contracts within the code binary.

2. Compile-Time Evaluation

Constants are not merely immutable variables; they are evaluated and "baked" into the program's binary during compile-time. This allows the compiler to perform constant expressions (like 60 * 60 * 3) before the program ever runs, optimizing performance.

3. Absolute Immutability

Constants serve as the "single source of truth." They cannot be made mutable with mut and cannot be shadowed in the same scope, ensuring the program's vital parameters remain untouched throughout execution.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

Which of the following is REQUIRED when declaring a constant in Rust?

The 'mut' keyword

A type annotation (e.g., : u32)

A semicolon before the name

The 'let' keyword

QUESTION 2

When are the values of constants calculated?

At runtime, when the variable is first accessed.

During program initialization only.

At compile-time.

Only when the user provides input.

QUESTION 3

Can a constant be shadowed in the same scope?

Yes, using the 'let' keyword.

Yes, if the value is the same type.

No, constants cannot be shadowed in the same scope.

Only within a function body.

QUESTION 4

What is a 'Constant Expression'?

An expression that returns a random number.

An expression that can be computed at compile-time.

A string literal that cannot be formatted.

A mathematical formula used only in 'mut' variables.

QUESTION 5

Which keyword is used to define a constant in Rust?

let immutable

define

const

static_val

Module: Security & Performance via Constants

Optimizing a Web Server's Configuration

You are developing a high-performance web server. You need to define a session timeout of 3 hours that is used across multiple modules. To prevent any logic from accidentally changing this duration and to ensure maximum runtime speed, you decide to use a constant.

1. Write the Rust code to define 'THREE_HOURS_IN_SECONDS' as a u32 constant.

Solution:
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
Note the mandatory type and the use of math that the compiler will solve.

2. Why is this more performant than using a standard variable?

Solution:
Because the value is computed at compile-time. The program doesn't waste CPU cycles at runtime doing the multiplication; it simply loads the final result (10800) directly from the binary.

3. If a developer tries to use shadowing or the 'mut' keyword on this constant, what happens?

Solution:
The compiler will throw an error. Constants do not support 'mut', and shadowing rules for variables do not apply to constants in the same way, preventing accidental state corruption.